#include<iostream>
#include<vector>
#include<functional>
#include<map>
using namespace std;


//struct Goods
//{
//    string _name; // 名字
//    double _price; // 价格
//    int _evaluate; // 评价
//    Goods(const char* str, double price, int evaluate)
//    :_name(str)
//    , _price(price)
//    , _evaluate(evaluate)
//    {}
//};
//struct ComparePriceLess
//{
//    bool operator()(const Goods& gl, const Goods& gr)
//    {
//        return gl._price < gr._price;
//    }
//};
//struct ComparePriceGreater
//{
//    bool operator()(const Goods& gl, const Goods& gr)
//    {
//        return gl._price > gr._price;
//    }
//};
//int main()
//{
//    vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2,3 }, { "菠萝", 1.5, 4 } };
//    sort(v.begin(), v.end(), ComparePriceLess());
//    ComparePriceGreater ct;
// //   sort(v.begin(), v.end(), ct);
//
//    sort(v.begin(),v.end(),[](const Goods& gl, const Goods& gr){return gl._price < gr._price;});
//}

//int main()
//{
//    int x,y;
//    x=119;
//    y=120;
//    cout<<"x="<<x<<":"<<"y="<<y<<endl;
//    auto f1=[&x,&y]()mutable//[]就是捕捉列表，可以捕捉lambda表达式所在函数里的变量，提供自己使用，这里的mutable用于捕捉后的变量可以修改，但是这里是引用捕捉，也可以不加mutable
//    {
//        int temp;
//        temp=x;
//        x=y;
//        y=temp;
//    };
//
//    f1();
//    cout<<"x="<<x<<":"<<"y="<<y<<endl;
//    return 0;
//}

//int main()
//{
//    int x = 1,y = 2,z = 3;
//    //以值的方式捕捉所有的变量
//    auto f1=[=](){
//        cout<<x<<y<<z<<endl;
//    };
//    f1();
//
//    //以引用的方式捕捉所有的变量
//    auto f2=[=](){
//        cout<<x<<y<<z<<endl;
//    };
//    f2();
//
//    //以值的方式捕捉所有的变量，指定x,y以引用捕捉
//    auto f3=[=,&x,&y](){
//        cout<<x<<y<<z<<endl;
//    };
//    f3();
//
//    return 0;
//}

//
//void swap_func(int& r1,int& r2)
//{
//    int temp;
//    temp=r1;
//    r1=r2;
//    r2=temp;
//}
//
//
//struct swap_2
//{
//    void operator()(int& r1,int& r2)
//    {
//        int temp;
//        temp=r1;
//        r1=r2;
//        r2=temp;
//    }
//};
//
//
//int main()
//{
//    int x=119;
//    int y=120;
//    auto lambdaswap=[](int& r1,int& r2)
//    {
//        int temp;
//        temp=r1;
//        r1=r2;
//        r2=temp;
//    };
//
//    //包装器指向swap_func函数
//    function<void(int&,int&)> f1=swap_func;
//    f1(x,y);
//    cout<<"x:"<<x<<"    y:"<<y<<endl;
//
//    //包装器指向仿函数
//    function<void(int&,int&)> f2=swap_2();//swap_2() 是一个函数调用操作符 operator() 被重载的类 swap_2 的匿名对象。在 C++ 中，类的对象也可以被当作函数使用，如果该类定义了一个函数调用操作符 operator()，就可以像调用函数一样使用这个对象。在这种情况下，swap_2() 返回的匿名对象会被当作函数使用，具体来说，它会被当作一个函数对象使用。
//    f2(x,y);
//    cout<<"x:"<<x<<"    y:"<<y<<endl;
//
//    //包装器指向lambda表达式
//    function<void(int&,int&)> f3=lambdaswap;
//    f3(x,y);
//    cout<<"x:"<<x<<"    y:"<<y<<endl;
//
//
//    return 0;
//}


//class Test
//{
//public:
//    int add(int x,int y)
//    {
//        return x+y;
//    }
//    static int add_s(int x,int y){
//        return x+y;
//    }
//};
//int main()
//{
//    //包装器指向静态成员函数
//    //需要加域名
//    function<int(int,int)> f1=Test::add_s;
//    int sum=f1(1,2);
//    cout<<sum<<endl;
//
//    //包装器指向普通成员函数
//    //1.需要加域名
//    //2.需要取地址
//    //3.function需要多加一个类的指针（因为成员函数的参数列表中，隐含一个this指针）
//    function<int(Test*,int,int)> f2=&Test::add;
//    Test t1;
//    int num=f2(&t1,1,2);
//    cout<<num<<endl;
//}


//class Test
//{
//public:
//    int add(int x,int y)
//    {
//        return x+y;
//    }
//    static int add_s(int x,int y){
//        return x+y;
//    }
//};
//
//int sub(int x,int y)
//{
//    return x-y;
//}
//
//int main()
//{
//    //调整参数顺序
//    function<int(int,int)> f1=bind(sub,placeholders::_2,placeholders::_1);
//    int num=f1(2,0);
//    cout<<num<<endl;
//
//    //调整参数个数
//    function<int(int)> f2=bind(sub,100,placeholders::_1);
//    int num1=f2(1);
//    cout<<num1<<endl;
//
//    //调整参数个数
//    function<int(int,int)>f3=bind(&Test::add,Test(),placeholders::_1,placeholders::_2);
//    int num2=f3(2,3);
//    cout<<num2<<endl;
//
//
//    return 0;
//}

